#include<bits/stdc++.h>
using namespace std;
const int N = 3e5+10;
int n;
bool st;
bool sta[N];
struct segment{
    bool flg[N<<2];
    void push_up(int now){
        flg[now] = flg[now<<1] && flg[now<<1|1];
    }
    void build(int now,int l,int r){
        if(l == r){
            flg[now] = sta[l];
            return;
        }
        int mid = (l + r)/2;
        build(now<<1,l,mid);
        build(now<<1|1,mid+1,r);
        push_up(now);
    }
    void update(int now,int l,int r,int p){
        if(l == r){
            sta[l] ^= 1;
            flg[now] ^= 1;
            return;
        }
        int mid = (l + r)/2;
        if(p <= mid){
            update(now<<1,l,mid,p);
        }else{
            update(now<<1|1,mid+1,r,p);
        }
        push_up(now);
    }
    int Rfarthest(int now,int l,int r){
        if(l == r){
            return l;
        }
        int mid = (l + r)/2;
        if(flg[now<<1] && sta[mid + 1]){
            return Rfarthest(now<<1|1,mid+1,r);
        }else{
            return Rfarthest(now<<1,l,mid);
        }
    }
    int Rfarthest(int now,int l,int r,int x,int y){
        if(x <= l && r <= y){
            return Rfarthest(now,l,r);
        } 
        int mid = (l + r)/2;
        int res = 0;
        if(x <= mid){
            res = Rfarthest(now<<1,l,mid,x,y);
            if(res == mid && mid < r && sta[mid+1]){
                return Rfarthest(now<<1|1,mid+1,r,x,y);
            }else{
                return res;
            }
        }else{
            return Rfarthest(now<<1|1,mid+1,r,x,y);
        }
    }
    int Lfarthest(int now,int l,int r){
        if(l == r){
            return l;
        }
        int mid = (l + r)/2;
        if(sta[mid]&&flg[now<<1|1]){
            return Lfarthest(now<<1,l,mid);
        }else{
            return Lfarthest(now<<1|1,mid+1,r);
        }
    }
    int Lfarthest(int now,int l,int r,int x,int y){
        if(x <= l && r <= y){
            return Lfarthest(now,l,r);
        }
        int mid = (l + r)/2;
        int res = 0;
        if(mid < y){
            res = Lfarthest(now<<1|1,mid+1,r,x,y);
            if(res == mid + 1 && sta[mid] && x <= mid){
                return Lfarthest(now<<1,l,mid,x,y);
            }else{
                return res;
            }
        }else{
            return Lfarthest(now<<1,l,mid,x,y);    
        }
    }
}sgt;
const int SIGLOG =40;
struct WBLT{
    int ls[SIGLOG*N],rs[SIGLOG*N];
    int siz[SIGLOG*N];
    int ti[SIGLOG*N];
    int L[SIGLOG*N],R[SIGLOG*N];
    struct pack{
        int sum,add;
    }pk[SIGLOG*N];
    int rub[N*SIGLOG];
    int rubp;
    int pcnt;
    int gen(){
        int now;
        if(rubp){
            now = rub[rubp--];
        }else{
            now = ++pcnt;
        }
        ls[now] = rs[now] = siz[now] = ti[now] = L[now] = R[now] = pk[now].sum = pk[now].add = 0;
        return now;
    }
    int gen(int x){
        int now = gen();
        L[now] = R[now] = x;
        siz[now] = 1;
        return now;
    }
    void push_up(int now){
        siz[now] = siz[ls[now]] + siz[rs[now]];
        ti[now] = max(ti[ls[now]],ti[rs[now]]);
        L[now] = L[ls[now]];
        R[now] = R[rs[now]];
        pk[now].add = pk[ls[now]].add + pk[rs[now]].add;
        pk[now].sum = pk[ls[now]].sum + pk[ls[now]].add*(ti[now] - ti[ls[now]]) + pk[rs[now]].sum + pk[rs[now]].add*(ti[now] - ti[rs[now]]);
    }
    int gen(int x,int y){
        int now = gen();
        ls[now] = x;
        rs[now] = y;
        push_up(now);
        return now;
    }
    void balence(int &now){
        if(max(siz[ls[now]],siz[rs[now]]) <= min(siz[ls[now]],siz[rs[now]])*3){
            return;
        }
        int a = ls[now],b = rs[now];
        rub[++rubp] = now;
        if(siz[a] > siz[b]){
            int la = ls[a],ra = rs[a];
            rub[++rubp] = a;
            if(siz[ra] <= 2*siz[la]){
                now = gen(la,gen(ra,b));
            }else{
                int lra = ls[ra],rra = rs[ra];
                rub[++rubp]  = ra;
                now = gen(gen(la,lra),gen(rra,b));
            }
        }else{
            int lb = ls[b],rb = rs[b];
            rub[++rubp] = b;
            if(siz[lb] <= 2*siz[rb]){
                now = gen(gen(a,lb),rb);
            }else{
                int llb = ls[lb],rlb = rs[lb];
                rub[++rubp] = lb;
                now = gen(gen(a,llb),gen(rlb,rb));
            }
        }
    }
    void update(int &now,int p,int v,int cur){
        if(!now){
            now = gen(p);
            pk[now].add = v;
            ti[now] = cur;
            return;
        }
        if(!ls[now]){
            if(p == L[now]){
                pk[now].sum += pk[now].add*(cur - ti[now]);
                pk[now].add += v;
                ti[now] = cur;
            }else{
                int ne = gen(p);
                pk[ne].add = v;
                ti[ne] = cur;
                if(p < L[now]){
                    now = gen(ne,now);
                }else{
                    now = gen(now,ne);
                }
            }
            return;
        }
        if(p <= R[ls[now]]){
            update(ls[now],p,v,cur);
        }else{
            update(rs[now],p,v,cur);
        }
        push_up(now);
        balence(now);
    }
    int query(int now,int x,int y,int cur){
        if(y < L[now] || R[now] < x){
            return 0;
        }
        if(x <= L[now] && R[now] <= y){
            return pk[now].sum + pk[now].add*(cur - ti[now] + 1);
        }
        int su = 0;
        su += query(ls[now],x,y,cur);
        su += query(rs[now],x,y,cur);
        return su;
    }
}wb;
struct BIT{
    int lowbit(int x){
        return x&(-x);
    }
    int rots[N];
    void update(int now,int p,int v,int cur){
        for(int i = now;i <= n;i += lowbit(i)){
            wb.update(rots[i],p,v,cur);   
        }
    }
    int query(int now,int x,int y,int cur){
        int res = 0;
        for(int i = now;i >= 1;i -= lowbit(i)){
            res += wb.query(rots[i],x,y,cur);
        }
        return res;
    }
}blt;
bool ed;
int main(){
    //cout<<(&ed - &st)/1048576.0<<'\n';
    int q;
    cin>>n>>q;
    string s;
    cin>>s;
    for(int i = 1;i<=n;i++){
        sta[i] = s[i - 1] - '0';
    }
    sgt.build(1,1,n);
    for(int i = 1;i<=n;i++){
        if(sta[i]){
            int ii = sgt.Rfarthest(1,1,n,i,n);
            blt.update(i,ii + 1,1,0);
            i = ii;
        }
    }
    for(int i = 1;i<=q;i++){
        string op;
        cin>>op;
        if(op == "query"){
            int a,b;
            cin>>a>>b;
            cout<<blt.query(a,b,n + 1,i - 1)<<'\n';
        }else{
            int x;
            cin>>x;
            if(sta[x]){
                int l = sgt.Lfarthest(1,1,n,1,x);
                int r = sgt.Rfarthest(1,1,n,x,n);
                blt.update(l,r + 1,-1,i);
                sgt.update(1,1,n,x);
                sta[x] = 0;
                if(sta[x - 1]){
                    blt.update(l,x - 1 + 1,1,i);
                }
                if(sta[x + 1]){
                    blt.update(x + 1,r + 1,1,i);
                }
            }else{
                int l = x,r = x;
                if(sta[x - 1]){
                    l = sgt.Lfarthest(1,1,n,1,x - 1);
                    blt.update(l,x - 1 + 1,-1,i);
                }
                if(sta[x + 1]){
                    r = sgt.Rfarthest(1,1,n,x + 1,n);
                    blt.update(x + 1,r + 1,-1,i);
                }
                sgt.update(1,1,n,x);
                blt.update(l,r + 1,1,i);
            }
        }
    }
}